package com.oneday.ashop.core.base.mongo;

import com.mongodb.WriteResult;
import com.oneday.ashop.core.entity.IncIdEntity;
import com.oneday.ashop.core.entity.Page;
import com.oneday.ashop.core.entity.sequence.Sequence;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.FindAndModifyOptions;
import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Term;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Repository;

import javax.annotation.PostConstruct;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/**
 * 数据库操作基类
 * User:bob.yang
 * Date 2015/7/16 0016
 */
@Data
@Slf4j
public abstract class BaseMongoDaoSupport {

    /**
     * 表的序列名称
     */
    private final String SEQUENCE_TABLE_NAME = "Sequence";

    /**
     * 类与主键泛型类型缓存
     */
    public static Map<String, String> classIdCache = new HashMap<>();

    /**
     * 默认的数据库操作
     */
    @Autowired
    protected MongoTemplate mongoTemplate;

    protected MongoOperations getMongoOpetation() {
        return mongoTemplate;
    }


    /**
     * 插入基本操作
     * @param toSaveObject
     */
    protected void  insert(IncIdEntity toSaveObject) {
        setId(toSaveObject);
        mongoTemplate.insert(toSaveObject);
    }

    /**
     * 基本的查询操作
     * @param query  查询条件
     * @param entityClass  查询类的class
     * @param <T>
     * @return
     */
    protected <T> List<T> find(Query query, Class<T> entityClass) {
        return mongoTemplate.find(query,entityClass);
    }

    /**
     * 基本的查询操作，查询单条
     * @param query
     * @param entityClass
     * @param <T>
     * @return
     */
    protected <T> T findOne(Query query, Class<T> entityClass) {
        return mongoTemplate.findOne(query, entityClass);
    }

    /**
     * 查询所有的数据
     * @param entityClass
     * @param <T>
     * @return
     */
    protected <T> List<T> findAll(Class<T> entityClass){
        return  mongoTemplate.findAll(entityClass);
    }

    /**
     * 更新第一个查询到的类
     * @param query
     * @param update
     * @param entityClass
     */
    protected void updateFirst(Query query, Update update, Class<?> entityClass){
        mongoTemplate.updateFirst(query, update,entityClass);
    }

    /**
     * 更新所有满足条件的
     * @param query
     * @param update
     * @param entityClass
     */
    protected void updateAll(Query query, Update update, Class<?> entityClass) {
        mongoTemplate.updateMulti(query, update, entityClass);
    }

    /**
     * 添加返回字段
     * @param query
     * @param fields
     */
    protected void includes(Query query, String...fields) {
       for(String str : fields) {
           query.fields().include(str);
       }
    }

    /**
     * 排除返回的字段
     * @param query
     * @param fields
     */
    protected  void excludes(Query query, String...fields) {
      for(String str : fields) {
          query.fields().exclude(str);
      }
    }


    /**
     * 修改表操作
     * @param query
     * @param update
     * @param entityClass
     */
    protected void findAndModify(Query query, Update update, Class<?> entityClass) {
        mongoTemplate.findAndModify(query, update, entityClass);
    }

    /**
     * 删除操作
     * @param query
     * @param entityClass
     */
    protected void delete(Query query, Class<?> entityClass) {
        mongoTemplate.remove(query, entityClass);
    }

    /**
     * 统计
     * @param query
     * @param clazz
     * @param <T>
     * @return
     */
    protected <T> Long count(Query query, Class<T> clazz){
        return mongoTemplate.count(query, clazz);
    }

    /**
     * 获得实体信息分页。调用该方法前需要做的：
     * <pre>
     *     1. 查询条件设置到query里
     *     2. 排序条件设置到query里
     * </pre>
     *
     * @param clazz   实体类
     * @param page    分页返回结果
     * @param query   查询
     * @param include fields是返回字段还是不返回字段
     * @param fields  返回字段
     * @param <T>     实体类
     */
    protected <T> void findEntityPage(Class<T> clazz, Page<T> page, Query query, boolean include, String... fields) {
        page.setTotal(count(query, clazz));
        if (include) {
            includes(query, fields);
        } else {
            excludes(query, fields);
        }
        query.skip(page.getIndex()).limit(page.getSize());
        page.setResult(find(query, clazz));
    }

    /**
     * 查询分页信息
     * @param clazz 结果实体
     * @param page 分页实体
     * @param query 查询条件
     * @param <T>泛型
     */
    protected <T> void findEntityPage(Class<T> clazz, Page<T> page, Query query) {
        page.setTotal(count(query, clazz));
        query.skip(page.getIndex()).limit(page.getSize());
        page.setResult(find(query, clazz));
    }


    /**
     * 处理表id自增
     * @param toSaveObject 需要插入的实体类
     * @return
     */
    protected void setId(IncIdEntity toSaveObject) {
        String className = toSaveObject.getClass().getName();
        Query query = Query.query(Criteria.where("_id").is(className));
        Update update = new Update().inc("seqNo", 1);
        Map<String, Object> map = mongoTemplate.findAndModify(query, update, FindAndModifyOptions.options().returnNew(true), HashMap.class, SEQUENCE_TABLE_NAME);
       //获得带有泛化类型的父类
        Type type = toSaveObject.getClass().getGenericSuperclass();
        String typeName = ((ParameterizedType)type).getActualTypeArguments()[0].getTypeName();
        if(map == null) {
            map = new HashMap<>();
            map.put("_id", className);
            //TODO 杨波　为了避免每次插入的时候都要用反射去做，这里反射的过程最好在项目启动的时候去做 后面优化
            if("java.lang.Integer".equals(typeName)) {
                map.put("seqNo", 1);
                toSaveObject.setId((Integer)map.get("seqNo"));
            }else {
                map.put("seqNo", 1L);
                toSaveObject.setId((Long)map.get("seqNo"));
            }
            mongoTemplate.insert(map, SEQUENCE_TABLE_NAME);
        }else {
            if("java.lang.Integer".equals(typeName)) {
                toSaveObject.setId((Integer)map.get("seqNo"));
            }else {
                toSaveObject.setId((Long)map.get("seqNo"));
            }
        }
    }
}
